#include "testcaseeditor.h"
#include "ui_testcaseeditor.h"
#include "ui_testcasedetaileditor.h" // 对应 TestCaseDetailEditor 的.ui文件
#include <QMessageBox>
#include <algorithm>
#include <QPushButton>

// -------------------------- TestCaseDetailEditor 实现（详情编辑逻辑） --------------------------
TestCaseDetailEditor::TestCaseDetailEditor(TestCaseManager* manager,
                                           const TestCase* testCase,
                                           QWidget *parent) :
    QWidget(parent),
    ui(new Ui::TestCaseDetailEditor),
    m_manager(manager),
    m_originalTestCase(testCase),
    m_currentGroupIndex(0) {
    ui->setupUi(this);
    setupEditUI(); // 初始化编辑界面控件

    // 加载配置数据（从管理器获取，缓存到本地）
    if (m_manager) {
        loadConfigData(m_manager->getConfigData());
    }

    // 加载原始案例（编辑时传入非nullptr，新增时为nullptr）
    if (m_originalTestCase) {
        loadOriginalTestCase(m_originalTestCase);
    } else {
        // 新增案例：默认创建1组空数据，避免无组报错
        m_currentEditingCase.testGroups.append(TestGroup());
        updateGroupLabel();
    }
}

TestCaseDetailEditor::~TestCaseDetailEditor() {
    delete ui;
}

// 初始化编辑界面的表格配置
void TestCaseDetailEditor::setupEditUI() {
    // 1. 左侧配置项表格（2列：选择框 + 数据名称）
    ui->configListTable->setColumnCount(2);
    ui->configListTable->setHorizontalHeaderLabels({"选择", "数据名称"});
    ui->configListTable->horizontalHeader()->setStretchLastSection(true);
    ui->configListTable->setSelectionBehavior(QAbstractItemView::SelectRows);

    // 2. 输入数据表格（3列：选择框 + 数据名称 + 数据值）
    ui->inputDataTable->setColumnCount(3);
    ui->inputDataTable->setHorizontalHeaderLabels({"", "数据名称", "数据值"});
    ui->inputDataTable->horizontalHeader()->setStretchLastSection(true);

    // 3. 预期结果表格（3列：选择框 + 数据名称 + 数据值）
    ui->expectedDataTable->setColumnCount(3);
    ui->expectedDataTable->setHorizontalHeaderLabels({"", "数据名称", "数据值"});
    ui->expectedDataTable->horizontalHeader()->setStretchLastSection(true);
}

// 填充左侧配置项列表（从缓存 m_allConfigData 加载）
void TestCaseDetailEditor::populateConfigDataList() {
    ui->configListTable->setRowCount(0); // 清空表格
    for (const auto& config : m_allConfigData) {
        int row = ui->configListTable->rowCount();
        ui->configListTable->insertRow(row);

        // 选择框（默认未勾选）
        QTableWidgetItem* checkItem = new QTableWidgetItem();
        checkItem->setCheckState(Qt::Unchecked);
        ui->configListTable->setItem(row, 0, checkItem);

        // 数据名称（不可编辑）
        QTableWidgetItem* nameItem = new QTableWidgetItem(config.name);
        nameItem->setFlags(nameItem->flags() & ~Qt::ItemIsEditable);
        ui->configListTable->setItem(row, 1, nameItem);
    }
}

// 按关键字过滤配置项（模糊匹配，不区分大小写）
void TestCaseDetailEditor::filterConfigData(const QString& keyword) {
    ui->configListTable->setRowCount(0);
    for (const auto& config : m_allConfigData) {
        if (keyword.isEmpty() || config.name.contains(keyword, Qt::CaseInsensitive)) {
            int row = ui->configListTable->rowCount();
            ui->configListTable->insertRow(row);

            QTableWidgetItem* checkItem = new QTableWidgetItem();
            checkItem->setCheckState(Qt::Unchecked);
            ui->configListTable->setItem(row, 0, checkItem);

            QTableWidgetItem* nameItem = new QTableWidgetItem(config.name);
            nameItem->setFlags(nameItem->flags() & ~Qt::ItemIsEditable);
            ui->configListTable->setItem(row, 1, nameItem);
        }
    }
}

// 获取左侧勾选的配置项
QList<ConfigItem> TestCaseDetailEditor::getCheckedConfigItems() {
    QList<ConfigItem> checkedItems;
    for (int row = 0; row < ui->configListTable->rowCount(); row++) {
        QTableWidgetItem* checkItem = ui->configListTable->item(row, 0);
        if (checkItem && checkItem->checkState() == Qt::Checked) {
            QString configName = ui->configListTable->item(row, 1)->text();
            // 从缓存中匹配对应的配置项（避免重复创建）
            auto it = std::find_if(m_allConfigData.begin(), m_allConfigData.end(),
                                   [&](const ConfigItem& item) { return item.name == configName; });
            if (it != m_allConfigData.end()) {
                checkedItems.append(*it);
            }
        }
    }
    return checkedItems;
}

// 向输入数据表格添加一行数据
void TestCaseDetailEditor::addInputDataToTable(const TestDataItem& item) {
    int row = ui->inputDataTable->rowCount();
    ui->inputDataTable->insertRow(row);

    QTableWidgetItem* checkItem = new QTableWidgetItem();
    checkItem->setCheckState(Qt::Unchecked);
    ui->inputDataTable->setItem(row, 0, checkItem);

    QTableWidgetItem* nameItem = new QTableWidgetItem(item.name);
    nameItem->setFlags(nameItem->flags() & ~Qt::ItemIsEditable);
    ui->inputDataTable->setItem(row, 1, nameItem);

    QTableWidgetItem* valueItem = new QTableWidgetItem(item.value);
    ui->inputDataTable->setItem(row, 2, valueItem);
}

// 向预期结果表格添加一行数据
void TestCaseDetailEditor::addExpectedDataToTable(const TestDataItem& item) {
    int row = ui->expectedDataTable->rowCount();
    ui->expectedDataTable->insertRow(row);

    QTableWidgetItem* checkItem = new QTableWidgetItem();
    checkItem->setCheckState(Qt::Unchecked);
    ui->expectedDataTable->setItem(row, 0, checkItem);

    QTableWidgetItem* nameItem = new QTableWidgetItem(item.name);
    nameItem->setFlags(nameItem->flags() & ~Qt::ItemIsEditable);
    ui->expectedDataTable->setItem(row, 1, nameItem);

    QTableWidgetItem* valueItem = new QTableWidgetItem(item.value);
    ui->expectedDataTable->setItem(row, 2, valueItem);
}

// 刷新当前组的输入/预期表格数据
void TestCaseDetailEditor::refreshGroupData() {
    if (m_currentEditingCase.testGroups.isEmpty()) return;

    // 获取当前组（避免重复索引访问）
    TestGroup& currentGroup = m_currentEditingCase.testGroups[m_currentGroupIndex];

    // 刷新输入表格
    ui->inputDataTable->setRowCount(0);
    for (const auto& item : currentGroup.inputData) { // 修复：inputDataList → inputData（匹配数据模型）
        addInputDataToTable(item);
    }

    // 刷新预期表格
    ui->expectedDataTable->setRowCount(0);
    for (const auto& item : currentGroup.expectedData) { // 修复：expectedDataList → expectedData
        addExpectedDataToTable(item);
    }
}

// 更新组标签（显示当前组/总组数）
void TestCaseDetailEditor::updateGroupLabel() {
    int totalGroups = m_currentEditingCase.testGroups.size();
    int currentGroup = m_currentGroupIndex + 1; // 索引从0开始，显示从1开始
    ui->groupLabel->setText(QString("当前组：%1/%2").arg(currentGroup).arg(totalGroups));

    // 控制按钮状态（避免越界操作）
    ui->prevGroupBtn->setEnabled(currentGroup > 1);    // 第一组不能上移
    ui->nextGroupBtn->setEnabled(currentGroup < totalGroups); // 最后一组不能下移
    ui->deleteGroupBtn->setEnabled(totalGroups > 1);   // 至少保留1组
}

// 加载配置数据到左侧表格
void TestCaseDetailEditor::loadConfigData(const QList<ConfigItem>& configData) {
    m_allConfigData = configData;
    populateConfigDataList(); // 填充到表格
}

// 加载原始案例到编辑界面
void TestCaseDetailEditor::loadOriginalTestCase(const TestCase* testCase) {
    if (!testCase) return;

    m_currentEditingCase = *testCase;
    m_currentGroupIndex = 0;

    if (m_currentEditingCase.testGroups.isEmpty()) {
        m_currentEditingCase.testGroups.append(TestGroup());
    }

    // 修复现有数据项的属性
    for (auto& group : m_currentEditingCase.testGroups) {
        // 修复输入数据
        for (auto& item : group.inputData) {
            auto it = std::find_if(m_allConfigData.begin(), m_allConfigData.end(),
                                   [&](const ConfigItem& config) { return config.name == item.name; });
            if (it != m_allConfigData.end()) {
                item.type = it->type;
                item.portOrCommid = it->portOrCommid;
                item.byteOffset = it->byteOffset;
                item.bitOffset = it->bitOffset;
            }
        }
        // 修复预期数据
        for (auto& item : group.expectedData) {
            auto it = std::find_if(m_allConfigData.begin(), m_allConfigData.end(),
                                   [&](const ConfigItem& config) { return config.name == item.name; });
            if (it != m_allConfigData.end()) {
                item.type = it->type;
                item.portOrCommid = it->portOrCommid;
                item.byteOffset = it->byteOffset;
                item.bitOffset = it->bitOffset;
            }
        }
    }

    ui->caseNameEdit->setText(testCase->name);
    refreshGroupData();
    updateGroupLabel();
}

// -------------------------- TestCaseDetailEditor 槽函数（编辑操作） --------------------------
// 修改输入数据添加逻辑，同步所有组
void TestCaseDetailEditor::on_addToInputBtn_clicked() {
    QList<ConfigItem> checkedConfigs = getCheckedConfigItems();
    if (checkedConfigs.isEmpty()) {
        QMessageBox::information(this, "提示", "请先在左侧勾选需要添加到输入数据的配置项！");
        return;
    }

    // 获取当前组的输入数据作为基准
    TestGroup& currentGroup = m_currentEditingCase.testGroups[m_currentGroupIndex];
    QList<TestDataItem> newItems;

    for (const auto& config : checkedConfigs) {
        // 检查当前组是否已存在
        bool isDuplicate = std::any_of(currentGroup.inputData.begin(), currentGroup.inputData.end(),
                                       [&](const TestDataItem& item) { return item.name == config.name; });
        if (isDuplicate) {
            QMessageBox::warning(this, "提示", QString("数据「%1」已存在于输入列表中！").arg(config.name));
            continue;
        }

        // 转换并添加到新项列表
        TestDataItem newItem;
        newItem.name = config.name;
        newItem.type = config.type;
        newItem.portOrCommid = config.portOrCommid; // 使用portOrCommid
        newItem.byteOffset = config.byteOffset;
        newItem.bitOffset = config.bitOffset;
        newItem.value = "0"; // 默认值
        newItems.append(newItem);
    }

    // 同步添加到所有组
    for (auto& group : m_currentEditingCase.testGroups) {
        for (const auto& item : newItems) {
            group.inputData.append(item);
        }
    }

    // 刷新当前组表格
    refreshGroupData();

    // 清空勾选框
    for (int row = 0; row < ui->configListTable->rowCount(); row++) {
        QTableWidgetItem* checkItem = ui->configListTable->item(row, 0);
        if (checkItem) checkItem->setCheckState(Qt::Unchecked);
    }
}

// 修改预期数据添加逻辑，同步所有组
void TestCaseDetailEditor::on_addToExpectedBtn_clicked() {
    QList<ConfigItem> checkedConfigs = getCheckedConfigItems();
    if (checkedConfigs.isEmpty()) {
        QMessageBox::information(this, "提示", "请先在左侧勾选需要添加到预期结果的配置项！");
        return;
    }

    // 获取当前组的预期数据作为基准
    TestGroup& currentGroup = m_currentEditingCase.testGroups[m_currentGroupIndex];
    QList<TestDataItem> newItems;

    for (const auto& config : checkedConfigs) {
        // 检查当前组是否已存在
        bool isDuplicate = std::any_of(currentGroup.expectedData.begin(), currentGroup.expectedData.end(),
                                       [&](const TestDataItem& item) { return item.name == config.name; });
        if (isDuplicate) {
            QMessageBox::warning(this, "提示", QString("数据「%1」已存在于预期列表中！").arg(config.name));
            continue;
        }

        // 转换并添加到新项列表
        TestDataItem newItem;
        newItem.name = config.name;
        newItem.type = config.type;
        newItem.portOrCommid = config.portOrCommid; // 使用portOrCommid
        newItem.byteOffset = config.byteOffset;
        newItem.bitOffset = config.bitOffset;
        newItem.value = "0"; // 默认值
        newItems.append(newItem);
    }

    // 同步添加到所有组
    for (auto& group : m_currentEditingCase.testGroups) {
        for (const auto& item : newItems) {
            group.expectedData.append(item);
        }
    }

    // 刷新当前组表格
    refreshGroupData();

    // 清空勾选框
    for (int row = 0; row < ui->configListTable->rowCount(); row++) {
        QTableWidgetItem* checkItem = ui->configListTable->item(row, 0);
        if (checkItem) checkItem->setCheckState(Qt::Unchecked);
    }
}

// 修改输入数据删除逻辑，同步所有组
void TestCaseDetailEditor::on_removeInputBtn_clicked() {
    TestGroup& currentGroup = m_currentEditingCase.testGroups[m_currentGroupIndex];
    QList<int> checkedRows;
    QList<QString> namesToRemove;

    // 收集勾选的行索引和对应的名称
    for (int row = 0; row < ui->inputDataTable->rowCount(); row++) {
        QTableWidgetItem* checkItem = ui->inputDataTable->item(row, 0);
        if (checkItem && checkItem->checkState() == Qt::Checked) {
            checkedRows.append(row);
            namesToRemove.append(ui->inputDataTable->item(row, 1)->text());
        }
    }

    if (checkedRows.isEmpty()) {
        QMessageBox::information(this, "提示", "请先勾选需要删除的输入数据项！");
        return;
    }

    // 从所有组中删除对应名称的输入项
    for (auto& group : m_currentEditingCase.testGroups) {
        for (const QString& name : namesToRemove) {
            auto it = std::remove_if(group.inputData.begin(), group.inputData.end(),
                                     [&](const TestDataItem& item) { return item.name == name; });
            group.inputData.erase(it, group.inputData.end());
        }
    }

    // 刷新当前组表格
    refreshGroupData();
}

// 修改预期数据删除逻辑，同步所有组
void TestCaseDetailEditor::on_removeExpectedBtn_clicked() {
    TestGroup& currentGroup = m_currentEditingCase.testGroups[m_currentGroupIndex];
    QList<int> checkedRows;
    QList<QString> namesToRemove;

    // 收集勾选的行索引和对应的名称
    for (int row = 0; row < ui->expectedDataTable->rowCount(); row++) {
        QTableWidgetItem* checkItem = ui->expectedDataTable->item(row, 0);
        if (checkItem && checkItem->checkState() == Qt::Checked) {
            checkedRows.append(row);
            namesToRemove.append(ui->expectedDataTable->item(row, 1)->text());
        }
    }

    if (checkedRows.isEmpty()) {
        QMessageBox::information(this, "提示", "请先勾选需要删除的预期数据项！");
        return;
    }

    // 从所有组中删除对应名称的预期项
    for (auto& group : m_currentEditingCase.testGroups) {
        for (const QString& name : namesToRemove) {
            auto it = std::remove_if(group.expectedData.begin(), group.expectedData.end(),
                                     [&](const TestDataItem& item) { return item.name == name; });
            group.expectedData.erase(it, group.expectedData.end());
        }
    }

    // 刷新当前组表格
    refreshGroupData();
}

void TestCaseDetailEditor::on_searchBtn_clicked() {
    // 过滤配置项（去除输入框空格）
    filterConfigData(ui->searchEdit->text().trimmed());
}

/**
 * @brief 同步 UI 表格数据到模型
 */
void TestCaseDetailEditor::syncUiToModel() {
    if (m_currentEditingCase.testGroups.isEmpty() || m_currentGroupIndex < 0 || m_currentGroupIndex >= m_currentEditingCase.testGroups.size()) {
        qWarning() << "syncUiToModel: No valid current group to sync.";
        return;
    }
    TestGroup& currentGroup = m_currentEditingCase.testGroups[m_currentGroupIndex];

    // 同步输入数据表格
    currentGroup.inputData.clear();
    for (int row = 0; row < ui->inputDataTable->rowCount(); ++row) {
        QTableWidgetItem* nameItem = ui->inputDataTable->item(row, 1);
        QTableWidgetItem* valueItem = ui->inputDataTable->item(row, 2);
        if (nameItem && valueItem && !nameItem->text().isEmpty()) {
            TestDataItem newItem;
            newItem.name = nameItem->text();
            newItem.value = valueItem->text();

            // 从配置缓存中补充属性
            auto it = std::find_if(m_allConfigData.begin(), m_allConfigData.end(),
                                   [&](const ConfigItem& item) { return item.name == newItem.name; });
            if (it != m_allConfigData.end()) {
                newItem.type = it->type;
                newItem.portOrCommid = it->portOrCommid;
                newItem.byteOffset = it->byteOffset;
                newItem.bitOffset = it->bitOffset;
            } else {
                qWarning() << "Config item not found: " << newItem.name;
            }

            currentGroup.inputData.append(newItem);
        }
    }

    // 同步预期结果表格（同上）
    currentGroup.expectedData.clear();
    for (int row = 0; row < ui->expectedDataTable->rowCount(); ++row) {
        QTableWidgetItem* nameItem = ui->expectedDataTable->item(row, 1);
        QTableWidgetItem* valueItem = ui->expectedDataTable->item(row, 2);
        if (nameItem && valueItem && !nameItem->text().isEmpty()) {
            TestDataItem newItem;
            newItem.name = nameItem->text();
            newItem.value = valueItem->text();

            // 从配置缓存中补充属性
            auto it = std::find_if(m_allConfigData.begin(), m_allConfigData.end(),
                                   [&](const ConfigItem& item) { return item.name == newItem.name; });
            if (it != m_allConfigData.end()) {
                newItem.type = it->type;
                newItem.portOrCommid = it->portOrCommid;
                newItem.byteOffset = it->byteOffset;
                newItem.bitOffset = it->bitOffset;
            } else {
                qWarning() << "Config item not found: " << newItem.name;
            }

            currentGroup.expectedData.append(newItem);
        }
    }

    qDebug() << "UI data synced to model for group" << m_currentGroupIndex;
}

void TestCaseDetailEditor::on_saveBtn_clicked() {
    QString caseName = ui->caseNameEdit->text().trimmed();
    if (caseName.isEmpty()) {
        QMessageBox::warning(this, "警告", "测试案例名称不能为空！");
        ui->caseNameEdit->setFocus();
        return;
    }

    // 这会将用户在表格中修改的所有新值，更新到 m_currentEditingCase 对象里。
    syncUiToModel();

    // 保存案例名称
    m_currentEditingCase.name = caseName;
    // 发送保存信号（由 TestCaseEditor 处理后续保存逻辑）
    emit saved(m_currentEditingCase);
    close(); // 关闭编辑界面

    // !!! 关键步骤：在保存之前，必须先调用 syncUiToModel() !!!
}

void TestCaseDetailEditor::on_cancelBtn_clicked() {
    // 发送取消信号（由 TestCaseEditor 处理界面切换）
    emit canceled();
    close(); // 关闭编辑界面
}

void TestCaseDetailEditor::on_addGroupBtn_clicked() {
    TestGroup newGroup;
    // 如果已有组，复制上一组的输入和预期数据结构（仅保留名称和类型等，值可以重置）
    if (!m_currentEditingCase.testGroups.isEmpty()) {
        const TestGroup& lastGroup = m_currentEditingCase.testGroups.last();
        // 复制输入数据结构
        for (const auto& item : lastGroup.inputData) {
            TestDataItem newItem = item;
            newItem.value = "0"; // 重置值
            newGroup.inputData.append(newItem);
        }
        // 复制预期数据结构
        for (const auto& item : lastGroup.expectedData) {
            TestDataItem newItem = item;
            newItem.value = "0"; // 重置值
            newGroup.expectedData.append(newItem);
        }
        newGroup.groupName = QString("组%1").arg(m_currentEditingCase.testGroups.size() + 1);
    } else {
        // 如果没有组，创建默认空组
        newGroup.groupName = "组1";
    }
    m_currentEditingCase.testGroups.append(newGroup);
    m_currentGroupIndex = m_currentEditingCase.testGroups.size() - 1;
    refreshGroupData();
    updateGroupLabel();
}

void TestCaseDetailEditor::on_deleteGroupBtn_clicked() {
    if (m_currentEditingCase.testGroups.size() <= 1) {
        QMessageBox::warning(this, "提示", "至少保留1组测试数据，无法删除！");
        return;
    }

    // 删除当前组
    m_currentEditingCase.testGroups.removeAt(m_currentGroupIndex);
    // 调整索引（避免越界）
    if (m_currentGroupIndex >= m_currentEditingCase.testGroups.size()) {
        m_currentGroupIndex = m_currentEditingCase.testGroups.size() - 1;
    }
    // 刷新表格和标签
    refreshGroupData();
    updateGroupLabel();
}

void TestCaseDetailEditor::on_prevGroupBtn_clicked() {
    if (m_currentGroupIndex > 0) {
        // !!! 关键步骤：在切换到上一组之前，先保存当前组的修改 !!!
        syncUiToModel();
        m_currentGroupIndex--;
        refreshGroupData();
        updateGroupLabel();
    }
}

void TestCaseDetailEditor::on_nextGroupBtn_clicked() {
    if (m_currentGroupIndex < m_currentEditingCase.testGroups.size() - 1) {
        // !!! 关键步骤：在切换到上一组之前，先保存当前组的修改 !!!
        syncUiToModel();
        m_currentGroupIndex++;
        refreshGroupData();
        updateGroupLabel();
    }
}

// -------------------------- TestCaseEditor 实现（列表管理逻辑） --------------------------
TestCaseEditor::TestCaseEditor(TestCaseManager* manager, QWidget *parent) :
    QWidget(parent),
    ui(new Ui::TestCaseEditor),
    m_manager(manager) {
    ui->setupUi(this);
    initTestCaseList(); // 初始化列表表格

    // 从管理器加载案例数据到缓存
    if (m_manager) {
        m_testCases = m_manager->getTestCases();
        refreshTestCaseList(); // 刷新列表显示
    }
}

TestCaseEditor::~TestCaseEditor() {
    // 释放编辑界面实例（避免内存泄漏）
    if (m_detailEditor) {
        m_detailEditor->deleteLater();
        m_detailEditor = nullptr;
    }
    delete ui;
}

// 初始化列表表格（列配置、样式）
void TestCaseEditor::initTestCaseList() {
    ui->testCaseList->setColumnCount(3);
    ui->testCaseList->setHorizontalHeaderLabels({"选择", "测试案例名称", "操作"});
    ui->testCaseList->horizontalHeader()->setStretchLastSection(true);
    ui->testCaseList->setSelectionBehavior(QAbstractItemView::SelectRows);
    ui->testCaseList->setEditTriggers(QAbstractItemView::NoEditTriggers); // 列表不可编辑
}

// 刷新列表数据（从缓存 m_testCases 加载到表格）
void TestCaseEditor::refreshTestCaseList() {
    ui->testCaseList->setRowCount(0); // 清空表格
    for (int i = 0; i < m_testCases.size(); ++i) {
        int row = ui->testCaseList->rowCount();
        ui->testCaseList->insertRow(row);

        // 选择框（默认未勾选）
        QTableWidgetItem* checkItem = new QTableWidgetItem();
        checkItem->setCheckState(Qt::Unchecked);
        ui->testCaseList->setItem(row, 0, checkItem);

        // 案例名称
        QTableWidgetItem* nameItem = new QTableWidgetItem(m_testCases[i].name);
        ui->testCaseList->setItem(row, 1, nameItem);

        // 编辑按钮（每行一个独立按钮）
        QPushButton* editBtn = new QPushButton("编辑");
        ui->testCaseList->setCellWidget(row, 2, editBtn);

        // 绑定编辑按钮：打开编辑界面并加载当前案例
        connect(editBtn, &QPushButton::clicked, [=]() {
            // 若编辑界面已存在，先关闭再重新创建（避免多个编辑窗口）
            if (m_detailEditor) {
                m_detailEditor->close();
                m_detailEditor->deleteLater();
            }
            // 创建编辑界面实例，传入当前案例
            m_detailEditor = new TestCaseDetailEditor(m_manager, &m_testCases[i], this);
            // 连接编辑界面的信号
            connect(m_detailEditor, &TestCaseDetailEditor::saved, this, &TestCaseEditor::onEditorSaved);
            connect(m_detailEditor, &TestCaseDetailEditor::canceled, this, &TestCaseEditor::onEditorCanceled);
            m_detailEditor->show();
            ui->groupBox->hide();
        });
    }
}

// -------------------------- TestCaseEditor 槽函数（列表操作） --------------------------
void TestCaseEditor::on_addBtn_clicked() {
    // 新增案例：编辑界面传入 nullptr（表示新增）
    if (m_detailEditor) {
        m_detailEditor->close();
        m_detailEditor->deleteLater();
    }
    m_detailEditor = new TestCaseDetailEditor(m_manager, nullptr, this);
    connect(m_detailEditor, &TestCaseDetailEditor::saved, this, &TestCaseEditor::onEditorSaved);
    connect(m_detailEditor, &TestCaseDetailEditor::canceled, this, &TestCaseEditor::onEditorCanceled);
    m_detailEditor->show();
    ui->groupBox->hide();
}

void TestCaseEditor::on_deleteBtn_clicked() {
    QList<int> selectedRows;
    // 收集勾选的案例行索引
    for (int i = 0; i < ui->testCaseList->rowCount(); ++i) {
        QTableWidgetItem* checkItem = ui->testCaseList->item(i, 0);
        if (checkItem && checkItem->checkState() == Qt::Checked) {
            selectedRows.append(i);
        }
    }

    if (selectedRows.isEmpty()) {
        QMessageBox::information(this, "提示", "请先选择要删除的测试案例！");
        return;
    }

    // 确认删除（避免误操作）
    if (QMessageBox::question(this, "确认删除", "确定要删除选中的测试案例吗？删除后不可恢复！") != QMessageBox::Yes) {
        return;
    }

    // 倒序删除（避免索引错乱）
    std::sort(selectedRows.rbegin(), selectedRows.rend());
    for (int row : selectedRows) {
        m_testCases.removeAt(row);
    }

    // 保存到管理器（持久化存储）
    if (m_manager) {
        m_manager->setTestCases(m_testCases);
        m_manager->saveTestCases();
    }

    // 刷新列表显示
    refreshTestCaseList();
}

void TestCaseEditor::on_editBtn_clicked() {
    QList<int> selectedRows;
    // 收集勾选的案例行索引
    for (int i = 0; i < ui->testCaseList->rowCount(); ++i) {
        QTableWidgetItem* checkItem = ui->testCaseList->item(i, 0);
        if (checkItem && checkItem->checkState() == Qt::Checked) {
            selectedRows.append(i);
        }
    }

    // 编辑只能选择一个案例
    if (selectedRows.size() != 1) {
        QMessageBox::information(this, "提示", "请选择一个测试案例进行编辑！");
        return;
    }

    // 打开编辑界面，传入选中的案例
    if (m_detailEditor) {
        m_detailEditor->close();
        m_detailEditor->deleteLater();
    }
    m_detailEditor = new TestCaseDetailEditor(m_manager, &m_testCases[selectedRows.first()], this);
    connect(m_detailEditor, &TestCaseDetailEditor::saved, this, &TestCaseEditor::onEditorSaved);
    connect(m_detailEditor, &TestCaseDetailEditor::canceled, this, &TestCaseEditor::onEditorCanceled);
    m_detailEditor->show();
    ui->groupBox->hide();
}

void TestCaseEditor::on_backBtn_clicked() {
    // 发送返回信号（主窗口接收后切换到主列表）
    emit backToTestList();
}

// -------------------------- TestCaseEditor 信号接收槽函数（处理编辑结果） --------------------------
void TestCaseEditor::onEditorSaved(TestCase testCase) {
    // 编辑完成：更新案例列表并保存到管理器
    bool isUpdate = false;
    // 检查是否是更新现有案例（按名称匹配）
    for (int i = 0; i < m_testCases.size(); ++i) {
        if (m_testCases[i].name == testCase.name) {
            m_testCases[i] = testCase;
            isUpdate = true;
            break;
        }
    }

    // 新增案例（名称不存在）
    if (!isUpdate) {
        m_testCases.append(testCase);
    }

    // 持久化保存到管理器
    if (m_manager) {
        m_manager->setTestCases(m_testCases);
        m_manager->saveTestCases();
    }

    // 刷新列表显示
    refreshTestCaseList();
    QMessageBox::information(this, "提示", isUpdate ? "案例更新成功！" : "案例新增成功！");
    ui->groupBox->show();
}

void TestCaseEditor::onEditorCanceled() {
    // 编辑取消：仅关闭编辑界面，不做其他操作
    QMessageBox::information(this, "提示", "编辑已取消，未保存任何修改！");
    ui->groupBox->show();
}
